home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Tools / linuxdoc-sgml-1.1 / sgmls-1.1 / sgmlmsg.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-03  |  11.1 KB  |  515 lines
  1. /* sgmlmsg.c -
  2.    message handling for core parser
  3.  
  4.    Written by James Clark (jjc@jclark.com).
  5. */
  6.  
  7. #include "config.h"
  8. #include "sgmlaux.h"
  9. #include "msg.h"
  10.  
  11. static nl_catd catd;
  12.  
  13. #define TEXT_SET 1        /* message set number for text of messages */
  14. #define HEADER_SET 2        /* message set number for header strings */
  15. #define PARM_SET 3        /* message set number for special parameters */
  16.  
  17. #ifdef HAVE_EXTENDED_PRINTF
  18. #define xfprintf fprintf
  19. #else
  20. extern int xfprintf VP((FILE *, char *,...));
  21. #endif
  22.  
  23. #define SIZEOF(v) (sizeof(v)/sizeof(v[0]))
  24.  
  25. static char *gettext P((int));
  26. static char *getheader P((int));
  27. static char *getparm P((int));
  28. static VOID elttrace P((FILE *, int));
  29. static int printit P((FILE *, struct error *));
  30. static char *transparm P((UNCH *, char *));
  31. static VOID spaces P((FILE *, int));
  32.  
  33. #define PARMBUFSIZ 50
  34. static char parmbuf[PARMBUFSIZ*2];
  35. static char *parmbuf1 = parmbuf;
  36. static char *parmbuf2 = parmbuf + PARMBUFSIZ;
  37.  
  38. static char *prog;        /* program name */
  39. static int sweltr;        /* non-zero means print an element trace */
  40. static int swenttr;        /* non-zero means print an entity trace */
  41. static int cnterr = 0;
  42. static VOID (*die) P((void));
  43.  
  44. static char *headers[] = {
  45. "In file included",
  46. "SGML error",                  /* parameters: type, severity, number */
  47. "Unsupported feature",              /* type U errors */
  48. "Error",                  /* for type R errors */
  49. "Warning",                  /* severity type I */
  50. " at %s, %.0sline %lu",              /* ignore entity name and ccnt */
  51. " at entity %s, line %lu",
  52. "%.0s%.0s in declaration parameter %d", /* ignore first two parameters */
  53. "%.0s in declaration parameter %d",     /* ignore first parameter */
  54. "%.0s",                        /* parse mode */
  55. " at end of file",
  56. " at end of entity",
  57. " at record start",
  58. " at record end",
  59. " at \"%c\"",
  60. " at \"\\%03o\"",
  61. " accessing \"%s\"",
  62. "Element structure:"
  63. };
  64.  
  65. /* Indexes into headers[] */
  66.  
  67. #define HDRPFX 0 
  68. #define HDRALL 1 
  69. #define HDRUNSUP 2 
  70. #define HDRSYS 3 
  71. #define HDRWARN 4 
  72. #define HDRLOC 5 
  73. #define HDRELOC 6 
  74. #define HDRMD 7 
  75. #define HDRMD2 8 
  76. #define HDRMODE 9 
  77. #define HDREOF 10
  78. #define HDREE 11
  79. #define HDRRS 12
  80. #define HDRRE 13
  81. #define HDRPRT 14
  82. #define HDRCTL 15
  83. #define HDRFIL 16
  84. #define HDRELT 17
  85.  
  86. /* Special parameters (error::errsp) */
  87. static char *parms[] = {
  88. "character data",
  89. "element content",
  90. "mixed content",
  91. "replaceable character data",
  92. "tag close",
  93. "content model group",
  94. "content model occurrence indicator",
  95. "name group",
  96. "name token group",
  97. "system data",
  98. "parameter literal",
  99. "attribute value literal",
  100. "tokenized attribute value literal",
  101. "minimum literal",
  102. "markup declaration",
  103. "markup declaration comment",
  104. "ignored markup declaration",
  105. "declaration subset",
  106. "CDATA marked section",
  107. "IGNORE marked section",
  108. "RCDATA marked section",
  109. "prolog",
  110. "reference",
  111. "attribute specification list",
  112. "tokenized attribute value",
  113. "attribute specification list close",
  114. "SGML declaration",
  115. "attribute definition list",
  116. "document type",
  117. "element",
  118. "entity",
  119. "link type",
  120. "link set",
  121. "notation",
  122. "SGML",
  123. "short reference mapping",
  124. "link set use",
  125. "short reference use",
  126. };
  127.  
  128. static FILE *tfp;        /* temporary file for saved messages */
  129.  
  130. struct saved {
  131.      long start;
  132.      long end;
  133.      char exiterr;
  134.      char countit;
  135. };
  136.  
  137. VOID msgprint(e)
  138. struct error *e;
  139. {
  140.      if (printit(stderr, e))
  141.       ++cnterr;
  142.      fflush(stderr);
  143.      if (e->errtype == EXITERR) {
  144.       if (die) {
  145.            (*die)();
  146.            abort();
  147.       }
  148.       else
  149.            exit(EXIT_FAILURE);
  150.      }
  151. }
  152.  
  153. /* Save an error message. */
  154.  
  155. UNIV msgsave(e)
  156. struct error *e;
  157. {
  158.      struct saved *sv;
  159.  
  160.      sv = (struct saved *)rmalloc(sizeof(struct saved));
  161.      if (!tfp) {
  162.       tfp = tmpfile();
  163.       if (!tfp)
  164.            exiterr(160, (struct parse *)0);
  165.      }
  166.      sv->start = ftell(tfp);
  167.      sv->countit = (char)printit(tfp, e);
  168.      sv->end = ftell(tfp);
  169.      sv->exiterr = (char)(e->errtype == EXITERR);
  170.      return (UNIV)sv;
  171. }
  172.  
  173. /* Print a saved error message. */
  174.  
  175. VOID msgsprint(p)
  176. UNIV p;
  177. {
  178.      struct saved *sv = (struct saved *)p;
  179.      long cnt;
  180.  
  181.      assert(p != 0);
  182.      assert(tfp != 0);
  183.      if (fseek(tfp, sv->start, SEEK_SET) < 0)
  184.       return;
  185.      /* Temporary files are opened in binary mode, so this is portable. */
  186.      cnt = sv->end - sv->start;
  187.      while (--cnt >= 0) {
  188.       int c = getc(tfp);
  189.       if (c == EOF)
  190.            break;
  191.       putc(c, stderr);
  192.      }
  193.      fflush(stderr);
  194.      if (sv->countit)
  195.       ++cnterr;
  196.      if (sv->exiterr)
  197.       exit(EXIT_FAILURE);
  198. }
  199.  
  200. /* Free a sved error message. */
  201.  
  202. VOID msgsfree(p)
  203. UNIV p;
  204. {
  205.      frem(p);
  206. }
  207.  
  208. /* Return 1 if it should be counted as an error. */
  209.  
  210. static int printit(efp, e)
  211. FILE *efp;
  212. struct error *e;
  213. {
  214.      int indent;
  215.      int countit;
  216.      int hdrcode;
  217.      int filelevel = -1, prevfilelevel = -1, toplevel;
  218.      struct location loc;
  219.      char type[2], severity[2];
  220.  
  221.      assert(e->errnum < SIZEOF(messages));
  222.      assert(messages[e->errnum].text != NULL);
  223.      if (prog) {
  224.       fprintf(efp, "%s: ", prog);
  225.       indent = strlen(prog) + 2; /* don't rely on return value of fprintf */
  226.       /* Don't want to waste too much space on indenting. */
  227.       if (indent > 10)
  228.            indent = 4;
  229.      }
  230.      else
  231.       indent = 4;
  232.      
  233.      for (toplevel = 0; getlocation(toplevel, &loc); toplevel++)
  234.       if (loc.filesw) {
  235.            prevfilelevel = filelevel;
  236.            filelevel = toplevel;
  237.       }
  238.      toplevel--;
  239.  
  240.      if (e->errtype == FILERR) {
  241.       toplevel--;
  242.       filelevel = prevfilelevel;
  243.      }
  244.      if (swenttr && filelevel > 0) {
  245.       int level = 0;
  246.       int middle = 0;    /* in the middle of a line */
  247.       do {
  248.            (void)getlocation(level, &loc);
  249.            if (loc.filesw) {
  250.             if (middle) {
  251.              fputs(":\n", efp);
  252.              spaces(efp, indent);
  253.             }
  254.             else
  255.              middle = 1;
  256.             xfprintf(efp, getheader(HDRPFX));
  257.             xfprintf(efp, getheader(HDRLOC), ioflid(loc.fcb),
  258.                  loc.ename, loc.rcnt, loc.ccnt);
  259.            }
  260.            else if (middle)
  261.             xfprintf(efp, getheader(HDRELOC),
  262.                  loc.ename, loc.rcnt + 1, loc.ccnt);
  263.       }
  264.       while (++level != filelevel);
  265.       if (middle) {
  266.            fputs(":\n", efp);
  267.            spaces(efp, indent);
  268.       }
  269.      }
  270.  
  271.      /* We use strings for the type and severity,
  272.     so that the format can use %.0s to ignore them. */
  273.  
  274.      type[0] = messages[e->errnum].type;
  275.      type[1] = '\0';
  276.      severity[0] = messages[e->errnum].severity;
  277.      severity[1] = '\0';
  278.  
  279.      countit = (severity[0] != 'I');
  280.      if (!countit)
  281.       hdrcode = HDRWARN;
  282.      else if (type[0] == 'R')
  283.       hdrcode = HDRSYS;
  284.      else if (type[0] == 'U')
  285.       hdrcode = HDRUNSUP;
  286.      else
  287.       hdrcode = HDRALL;
  288.       
  289.      xfprintf(efp, getheader(hdrcode), type, severity, e->errnum);
  290.  
  291.      if (filelevel >= 0) {
  292.       (void)getlocation(filelevel, &loc);
  293.       xfprintf(efp, getheader(HDRLOC),
  294.            ioflid(loc.fcb), loc.ename, loc.rcnt, loc.ccnt);
  295.       while (filelevel < toplevel) {
  296.            ++filelevel;
  297.            if (swenttr) {
  298.             (void)getlocation(filelevel, &loc);
  299.             xfprintf(efp, getheader(HDRELOC),
  300.                  loc.ename, loc.rcnt + 1, loc.ccnt);
  301.            }
  302.       }
  303.      }
  304.      
  305.      /* It is necessary to copy the result of getparm() because
  306.     the specification of catgets() says in can return a 
  307.     pointer to a static buffer which may get overwritten
  308.     by the next call to catgets(). */
  309.  
  310.      switch (e->errtype) {
  311.      case MDERR:
  312.       strncpy(parmbuf, getparm(e->errsp), PARMBUFSIZ*2 - 1);
  313.       xfprintf(efp, getheader(HDRMD), parmbuf,
  314.            (e->subdcl ? e->subdcl : (UNCH *)""), e->parmno);
  315.       break;
  316.      case MDERR2:
  317.       /* no subdcl parameter */
  318.       strncpy(parmbuf, getparm(e->errsp), PARMBUFSIZ*2 - 1);
  319.       xfprintf(efp, getheader(HDRMD2), parmbuf, e->parmno);
  320.       break;
  321.      case DOCERR:
  322.      case EXITERR:
  323.       if (toplevel < 0)
  324.            break;
  325.       strncpy(parmbuf, getparm(e->errsp), PARMBUFSIZ*2 - 1);
  326.       xfprintf(efp, getheader(HDRMODE), parmbuf);
  327.       switch (loc.curchar) {
  328.       case EOFCHAR:
  329.            xfprintf(efp, getheader(HDREOF));
  330.            break;
  331.       case RSCHAR:
  332.            xfprintf(efp, getheader(HDRRS));
  333.            break;
  334.       case RECHAR:
  335.            xfprintf(efp, getheader(HDRRE));
  336.            break;
  337.       case DELNONCH:
  338.            xfprintf(efp, getheader(HDRCTL), UNSHIFTNON(loc.nextchar));
  339.            break;
  340.       case EOS:
  341.            xfprintf(efp, getheader(HDREE));
  342.            break;
  343.       case EOBCHAR:
  344.            break;
  345.       default:
  346.            if (ISASCII(loc.curchar) && isprint(loc.curchar))
  347.             xfprintf(efp, getheader(HDRPRT), loc.curchar);
  348.            else
  349.             xfprintf(efp, getheader(HDRCTL), loc.curchar);
  350.            break;
  351.       }
  352.       break;
  353.      case FILERR:
  354.       if (getlocation(toplevel + 1, &loc))
  355.            xfprintf(efp, getheader(HDRFIL), ioflid(loc.fcb));
  356.       break;
  357.      }
  358.      fputs(":\n", efp);
  359.  
  360.      if (e->errtype == FILERR && e->sverrno != 0) {
  361.       char *errstr = strerror(e->sverrno);
  362.       UNS len = strlen(errstr);
  363.       /* Strip a trailing newline if there is one. */
  364.       if (len > 0 && errstr[len - 1] == '\n')
  365.            len--;
  366.       spaces(efp, indent);
  367.       for (; len > 0; len--, errstr++)
  368.            putc(*errstr, efp);
  369.       fputs(":\n", efp);
  370.      }
  371.  
  372.      spaces(efp, indent);
  373.  
  374.      xfprintf(efp, gettext(e->errnum),
  375.           transparm((UNCH *)e->eparm[0], parmbuf1),
  376.           transparm((UNCH *)e->eparm[1], parmbuf2));
  377.      putc('\n', efp);
  378.  
  379.      if (sweltr)
  380.       elttrace(efp, indent);
  381.      return countit;
  382. }
  383.  
  384. /* Print an element trace. */
  385. static VOID elttrace(efp, indent)
  386. FILE *efp;
  387. int indent;
  388. {
  389.      int i = 1;
  390.      UNCH *gi;
  391.      
  392.      gi = getgi(i);
  393.      if (!gi)
  394.       return;
  395.      spaces(efp, indent);
  396.      xfprintf(efp, getheader(HDRELT));
  397.      do {
  398.       fprintf(efp, " %s", gi);
  399.       gi = getgi(++i);
  400.      } while (gi);
  401.      putc('\n', efp);
  402. }
  403.  
  404. static VOID spaces(efp, indent)
  405. FILE *efp;
  406. int indent;
  407. {
  408.      while (--indent >= 0)
  409.       putc(' ', efp);
  410. }
  411.  
  412. VOID msginit(swp)
  413. struct switches *swp;
  414. {
  415.      catd = swp->catd;
  416.      prog = swp->prog;
  417.      sweltr = swp->sweltr;
  418.      swenttr = swp->swenttr;
  419.      die = swp->die;
  420. }
  421.  
  422. /* Return the error count. */
  423.  
  424. int msgcnterr()
  425. {
  426.      return cnterr;
  427. }
  428.  
  429. /* Transform a parameter into a form suitable for printing. */
  430.  
  431. static char *transparm(s, buf)
  432. UNCH *s;
  433. char *buf;
  434. {
  435.      char *ptr;
  436.      int cnt;
  437.  
  438.      if (!s)
  439.       return 0;
  440.  
  441.      ptr = buf;
  442.      cnt = PARMBUFSIZ - 4;    /* space for `...\0'  */
  443.  
  444.      while (*s) {
  445.       UNCH ch = *s++;
  446.       if (ch == DELNONCH) {
  447.            if (*s == '\0')
  448.             break;
  449.            ch = UNSHIFTNON(*s);
  450.            s++;
  451.       }
  452.       if (ch == DELCDATA || ch == DELSDATA)
  453.            ;
  454.       else if (ch == '\\') {
  455.            if (cnt < 2)
  456.             break;
  457.            *ptr++ = '\\';
  458.            *ptr++ = '\\';
  459.            cnt -= 2;
  460.       }
  461.       else if (ISASCII(ch) && isprint(ch)) {
  462.            if (cnt < 1)
  463.             break;
  464.            *ptr++ = ch;
  465.            cnt--;
  466.       }
  467.       else {
  468.            if (cnt < 4)
  469.             break;
  470.            sprintf(ptr, "\\%03o", ch);
  471.            ptr += 4;
  472.            cnt -= 4;
  473.       }
  474.      }
  475.      if (!*s)
  476.       *ptr = '\0';
  477.      else
  478.       strcpy(ptr, "...");
  479.      return buf;
  480. }
  481.  
  482. /* The message and set numbers in the catgets function must be > 0. */
  483.  
  484. static char *gettext(n)
  485. int n;
  486. {
  487.      assert(n > 0 && n < SIZEOF(messages));
  488.      assert(messages[n].text != 0);
  489.      return catgets(catd, TEXT_SET, n, messages[n].text);
  490. }
  491.  
  492. static char *getheader(n)
  493. int n;
  494. {
  495.      assert(n >= 0 && n < SIZEOF(headers));
  496.      return catgets(catd, HEADER_SET, n + 1, headers[n]);
  497. }
  498.  
  499. static char *getparm(n)
  500. int n;
  501. {
  502.      assert(n >= 0 && n < SIZEOF(parms));
  503.      return catgets(catd, PARM_SET, n + 1, parms[n]);
  504. }
  505.  
  506. /*
  507. Local Variables:
  508. c-indent-level: 5
  509. c-continued-statement-offset: 5
  510. c-brace-offset: -5
  511. c-argdecl-indent: 0
  512. c-label-offset: -5
  513. End:
  514. */
  515.